4  Manipulação de Strings com STRINGR

4.1 Introdução

A seguir temos vários exemplos de manipulação de strings (cadeia de caracteres) utilizando o pacote STRINGR do R. Para saber mais sobre este pacote, acesse:

https://cran.r-project.org/package=stringr.

Para os exemplos, iremos carregar os seguintes pacotes:

• tidyverse

• htmlwidgets

library (tidyverse)
library (htmlwidgets)

Nota

String: O termo string, ou cadeia de caracteres, é uma sequência de caracteres interpretadas como uma constante literal ou até mesmo uma variável. No R, podemos criar uma string com aspas simples ou duplas.

Por exemplo:

minha_string <- "Isto é uma string"
minha_string

[1] "Isto é uma string"

minha_outra_string <- 'Isto também é uma string'
minha_outra_string

[1] "Isto também é uma string"

4.1.1 Exemplos da Folha de Referência

A maioria dos exemplos, visam ajudar na interpretação dos exemplos e funções encontradas na Folha de Referência do stringr disponível no site do RStudio.

---

Para a maioria dos exemplos utilizaremos as bases de dados fruit (frutas) que será criado a seguir.

FRUIT: Tabela com nome de frutas (em inglês).

fruit <- tibble(name = c("Apple", "Apricot", "Avocado", "Banana", "Blackberry", "Blueberry", "Cherry", "Coconut", "Custard-Apple", "Dragonfruit", "Fig", "Gooseberry", "Grapes", "Guava", "Jackfruit", "Java Plum", "Kiwifruit", "Lime", "Mango", "MuskMelon", "Olives", "Orange", "Papaya", "Peach", "Pear", "Pineapple", "Pomegranate", "Strawberry", "Tamarind", "Watermelon"))
fruit 

---

4.2 Detectando Combinações

O pacote stringr possui uma série de funções para identificar a ocorrência ou não de padrões de caracteres (patterns).

Na maioria das vezes o mecanismo de interpretação padrão é o de “Expressão Regular” (regex). Isto significa que podemos construir um padrão de caracteres não somente com letras ou números, mas criando expressões que significam uma combinação mais flexivel no padrão de busca.

Para maiores informações veja: Expressões Regulares.

O pacote stringr, possui uma série de funções para manipulação de strings que veremos a seguir:

4.2.0.1 str_detect

Use para detectar a presença de um padrão em uma string.

Por exemplo, para detectar quais frutas tem a letra “a”, podemos usar:

str_detect(fruit$name, "a") 

 [1] FALSE FALSE  TRUE  TRUE  TRUE FALSE FALSE FALSE  TRUE  TRUE FALSE FALSE
[13]  TRUE  TRUE  TRUE  TRUE FALSE FALSE  TRUE FALSE FALSE  TRUE  TRUE  TRUE
[25]  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE

No exemplo acima, temos TRUE para todas as linhas que contém a letra “a” e FALSE para aquelas que não tem a letra “a”.

Importante

Observe que o R é sensível à letras maiúsculas e minúsculas. Como definimos a letra “a” (minúscula) como nosso padrão de busca, ele não retorna TRUE para palavras como “Apple” que possui a letra “A” maiúscula.

Se quisermos criar uma coluna ao lado para facilitar a visualização, podemos usar a função mutate() do pacote dplyr:

fruit |> 
  mutate (Padrao_Encontrado = str_detect(fruit$name, "a")) 

4.2.0.2 str_starts

Use para determinar se há o padrão definido no início da string.

Por exemplo, se quisermos identificar quais frutas que começam com o padrão “Bl”, usamos:

fruit |> 
  mutate (Padrao_Encontrado_Inicio = str_starts(fruit$name, "Bl")) 

Veja que apenas as frutas “Blackberry” e “Bluberry” retornaram verdadeiro (TRUE).

É comum utilizar a função filter() para filtrar apenas as linhas que retornam verdadeiro (TRUE) nas funções de detecção de padrão com o str_detect, str_starts, etc. Veja o exemplo abaixo:

fruit |> 
  filter (str_starts(name, "Bl")) 

4.2.0.3 str_which

Use para retornar em qual linha o pdrão foi encontrado.

Por exemplo, supondo que o padrão sejam as letras “Bl” (B maiúscula e l minúscula), usamos:

str_which(fruit$name, "Bl")

[1] 5 6

Neste exemplo, identificamos que os únicos registros que atendem ao padrão “Bl” estão nas linhas 5 e 6 da tabela.

4.2.0.4 str_locate

Use para localizar a posição do padrão na string.

Por exemplo, se criarmos uma coluna contendo onde, em cada nome de fruta, o padrão de busca “er” é encontrado, usamos:

fruit |> 
  mutate (Localização_na_string = str_locate(name, "er")) 

A função str_locale retorna NA caso o padrão não seja encontrado na string.

Dica

Ao encontrar o padrão, a str_locale para imediatamente a busca na string. Caso precise encontrar todas as posições que o padrão existir na mesma string, utiliza a str_locale_all().

4.2.0.5 str_count

Use para identificar o número de vez que o padrão foi encontrado na string.

Por exemplo, se buscarmos pelo padrão “na”, identificamos que a fruta banana, possui o padrão três vezes, enquanto a fruta pomegranade apenas uma vez.

fruit |> 
  mutate (Vezes_padrao_encontrado = str_count(name, "na")) 

4.3 Partes da String

O pacote stringr possui uma série de funções que permitem obter partes de uma string baseado em um padrão de busca. Assim como nas funções de detecção, o interpretador padrão é o regex. Para maiores informações veja: Expressões Regulares.

4.3.0.1 str_sub

Use para extrair ou substituir partes de uma string a partir de um vetor de caracteres.

Por exemplo, para extrair do segundo até o quarto caractere dos nomes das frutas, usamos:

fruit |> 
  mutate (Segundo_ao_Quarto_Caractere = str_sub(name, 2, 4)) 

Se precisarmos variar o início ou fim da extração de parte da string, podemos passar valores negativos para os parametros start = e/ou end =, fazendo com que a contagem acontece de trás para frente.

4.3.0.2 str_subset

Use para retornar as strings que contém o padrão. É equivalente a fazer str_detect(x, pattern), porém ao invés de retornar verdadeiro ou falso, retorna a string.

str_subset(fruit$name, "Bl")

[1] "Blackberry" "Blueberry" 

4.3.0.3 str_extract

Use para obter o padrão encontrado na string.

Por exemplo, queremos obter parte da string que atenda ao padrão “erry”. Neste caso, a função irá retornar NA para as strings que não contém o padrão e o padrão para aquelas que o contém.

fruit |> 
  mutate (Str_Extract = str_extract(name, "erry")) 

4.3.0.4 str_match

Use para obter os grupos identificados pelo padrão de busca. Ela retorna uma matriz, onde a primeira coluna retorna a combinação (match) toda e as demais colunas será uma para cada grupo identificado.

Por exemplo, se buscarmos por dois grupos, sendo o primeiro (Ba) e o segundo grupo (na), teremos o seguinte resultado:

str_match(fruit$name, "(Ba)(na)") |> 
  as_tibble(.name_repair = "unique")

Nota

Os detalhes sobre grupos nos padrões de busca faz parte das expressões regulares (regex) e estão mais detalhadas na seção: Expressões Regulares

4.4 Gerenciando Tamanho

4.4.0.1 str_length

Use para obter o tamanho da string.

Por exemplo, para obtermos o tamanho das strings correspondentes aos nomes das frutas e adicioná-las em uma coluna chamada “Tamanho”, podemos fazer:

fruit |> 
  mutate(Tamanho = str_length(name)) 

4.4.0.2 str_pad

Use para adicionar espaços em branco ao lado (esquerdo, direito, ambos) da string.

Por exemplo, para adicionar espaços em branco para ajustar em 20 caracteres os nomes das frutas, usamos:

fruit |> mutate(Tamanho = str_pad(name, 20, "left")) |> as.matrix()

      name            Tamanho               
 [1,] "Apple"         "               Apple"
 [2,] "Apricot"       "             Apricot"
 [3,] "Avocado"       "             Avocado"
 [4,] "Banana"        "              Banana"
 [5,] "Blackberry"    "          Blackberry"
 [6,] "Blueberry"     "           Blueberry"
 [7,] "Cherry"        "              Cherry"
 [8,] "Coconut"       "             Coconut"
 [9,] "Custard-Apple" "       Custard-Apple"
[10,] "Dragonfruit"   "         Dragonfruit"
[11,] "Fig"           "                 Fig"
[12,] "Gooseberry"    "          Gooseberry"
[13,] "Grapes"        "              Grapes"
[14,] "Guava"         "               Guava"
[15,] "Jackfruit"     "           Jackfruit"
[16,] "Java Plum"     "           Java Plum"
[17,] "Kiwifruit"     "           Kiwifruit"
[18,] "Lime"          "                Lime"
[19,] "Mango"         "               Mango"
[20,] "MuskMelon"     "           MuskMelon"
[21,] "Olives"        "              Olives"
[22,] "Orange"        "              Orange"
[23,] "Papaya"        "              Papaya"
[24,] "Peach"         "               Peach"
[25,] "Pear"          "                Pear"
[26,] "Pineapple"     "           Pineapple"
[27,] "Pomegranate"   "         Pomegranate"
[28,] "Strawberry"    "          Strawberry"
[29,] "Tamarind"      "            Tamarind"
[30,] "Watermelon"    "          Watermelon"

4.4.0.3 str_trunc

Use para truncar a string em um número fixo de caracteres.

Por exemplo, para truncar os nomes das frutas em até 8 caracteres, usamos:

fruit |> mutate(Tamanho = str_trunc(name, 8, "right")) |> as.matrix()

      name            Tamanho   
 [1,] "Apple"         "Apple"   
 [2,] "Apricot"       "Apricot" 
 [3,] "Avocado"       "Avocado" 
 [4,] "Banana"        "Banana"  
 [5,] "Blackberry"    "Black..."
 [6,] "Blueberry"     "Blueb..."
 [7,] "Cherry"        "Cherry"  
 [8,] "Coconut"       "Coconut" 
 [9,] "Custard-Apple" "Custa..."
[10,] "Dragonfruit"   "Drago..."
[11,] "Fig"           "Fig"     
[12,] "Gooseberry"    "Goose..."
[13,] "Grapes"        "Grapes"  
[14,] "Guava"         "Guava"   
[15,] "Jackfruit"     "Jackf..."
[16,] "Java Plum"     "Java ..."
[17,] "Kiwifruit"     "Kiwif..."
[18,] "Lime"          "Lime"    
[19,] "Mango"         "Mango"   
[20,] "MuskMelon"     "MuskM..."
[21,] "Olives"        "Olives"  
[22,] "Orange"        "Orange"  
[23,] "Papaya"        "Papaya"  
[24,] "Peach"         "Peach"   
[25,] "Pear"          "Pear"    
[26,] "Pineapple"     "Pinea..."
[27,] "Pomegranate"   "Pomeg..."
[28,] "Strawberry"    "Straw..."
[29,] "Tamarind"      "Tamarind"
[30,] "Watermelon"    "Water..."

Dica

Observe que a função adiciona “…” para identificar as strings que tinham mais que o limite definido”. Utilize o parametro ellipsis = “…” para alterar para outros caracteres.

4.4.0.4 str_trim

Use para remover os espaços em brancos do início em final da string.

string <- "  Aqui temos espaços em branco no início e no final   "
str_trim(string)

[1] "Aqui temos espaços em branco no início e no final"

4.4.0.5 str_squish

Use para remover espaços em branco no início e final da string e também espaços em brancos repetidos no meio da string.

string <- "  Aqui temos espaços em       branco no início, no final e repetidos no meio   "
str_squish(string)

[1] "Aqui temos espaços em branco no início, no final e repetidos no meio"

4.5 Modificando String

4.5.0.1 str_sub

Use para extrair ou substituir partes de uma string a partir de um vetor de caracteres.

Por exemplo, para substituir do segundo até o quarto caractere dos nomes das frutas, usamos:

minha_string <- "Esta é minha string"; minha_string

[1] "Esta é minha string"

str_sub(minha_string, 2, 4) <- "XXX"; minha_string

[1] "EXXX é minha string"

Dica

Observe que a função str_sub não é vetorizada, ou seja, não recebe ou retorna um vetor como parêmetro.

Desta forma, se quisermos aplicá-la em conjunto com a função mutate(). Uma alternativa para este tipo de situação, é utilziar a função map() do pacote purrr.

Por exemplo, vamos criar uma função chamada “substitui_string”. Esta função irá utilizar a função str_sub() de acordo com os parametros recebidos de str_troca, inicio e fim. Utilizando a função purrr::map() iremos iterar através dos nomes das frutas e utilizar a função substitui_string() para trocar por “XX” os caracteres -2 a -3 de todos os nomes em uma coluna ao lado.

substitui_string <- function(str_origin, str_troca, inicio, fim){
  str_sub(str_origin, inicio, fim) <- str_troca
  return (str_origin)
}

fruit |> 
  mutate (Segundo_ao_Quarto_Caracteres = purrr::map_chr (name, substitui_string, str_troca = "XX", inicio = -3, fim = -2))

Nota

Observe que valores negativos para os parametros start = e/ou end =, fazem com que a contagem aconteça de trás para frente.

4.5.0.2 str_replace

Use para substituir partes de uma string por outra string de acordo com o padrão de busca (ex: regex) definido.

Dica

Para saber mais sobre o método de expressão regular (regex) veja: Expressões Regulares e para os outros métodos de interpretação, veja Outras Interpretações.

Por exemplo, vamos definir inicialmente que nosso padrão de busca são as letras “er”. Agora vamos substituir este padrão pela string ” XX ” colocando em uma coluna ao lado usando a função mutate().

fruit |> 
  mutate (nomes_substituidos = str_replace(name, "er", " XX ")) 

Nota

Note que diferente da função str_sub(), a função str_replace() é vetorizada, com isto não precisamos utilizar o purrr:map para retornar um vetor.

4.5.0.3 str_replace_all

Use para substituir partes de uma string por outra string de acordo com o padrão de busca (ex: regex) definido em TODAS as vezes que o padrão for encontrado.

Por exemplo, vamos definir inicialmente que nosso padrão de busca são as letras “na”. Agora vamos substituir este padrão pela string ” XX ” colocando em uma coluna ao lado usando a função mutate().

fruit |> 
  mutate (nomes_substituidos = str_replace_all(name, "an", " XX "))

Note que se tivessemo utilizado a função str_replace ao invés da str_replace_all, a palavra “Banana” retornaria “Ba XX na”, pois ela substituiria apenas a primeira vez que o padrão fosse encontrado.

4.5.0.4 str_to_lower

Use para colocar a string em letras minúsculas.

fruit |> 
  mutate (tolowe = str_to_lower(name)) 

4.5.0.5 str_to_upper

Use para colocar a string em letras maiúsculas.

fruit |> 
  mutate (toupper = str_to_upper(name)) 

4.5.0.6 str_to_title

Use para colocar a string com a primeira letra maiúscula e as demais em letras minúsculas de cada palavra.

fruit |> 
  mutate (totitle= str_to_title(name)) 

4.6 Juntando e Dividindo

4.6.0.1 str_c

Use para juntar várias strings em uma única string.

Para exemplificar, vamos criar uma segunda coluna em nossa tabela de frutas.

# Nova coluna com uma string qualquer 
col_nova <- bind_cols(c(letters, LETTERS), seq(1:52), seq(1:52), c(letters, LETTERS))
col_nova <- col_nova |> 
  unite(nova_string, names(col_nova)) |> 
  slice (n = 1:30) 
frutas <- bind_cols (fruit, col_nova)

#Concatenando ambas colunas
  frutas |> 
  mutate ( str_c = str_c(name, nova_string)) 

Dica

Use o parametro sep = para definir um caractere de separação quando juntar as strings se desejar.

4.6.0.2 str_flatten

Use para “achatar” o vetor de string. O parametro collapse = “” pode ser alterado para incluir um caractere específico enquanto ocorre o processo.

Por exemplo, temos uma string “Bom dia”. Neste caso, temos um vetor de caracteres de tamanho 7 (“B” “o” “m” ” ” “d” “i” “a”). A função flatten irá achatar este vetor e retornar apenas uma string com um único vetor (“Bom dia”).

minha_string <- c("B","o","m"," ","d","i","a")
length (minha_string); minha_string

[1] 7

[1] "B" "o" "m" " " "d" "i" "a"

minha_string <- str_flatten(minha_string)
length (minha_string); minha_string

[1] 1

[1] "Bom dia"

4.6.0.3 str_dup

Use para duplicar uma string determinado número de vezes.

fruit |> 
  mutate (str_dup = str_dup(name, 3)) 

4.6.0.4 str_split_fixed

Use para “quebrar” um string em partes. A funçao str_split() retorna uma string dividida enquanto a funçao str_split_fixed() retorna uma matriz de caracteres com número fixo de colunas.

Por exemplo, vamos usar a mesma tabela usada no exemplo da funçao str_c chamada frutas (na fruit). Iremos “quebrar as strings da coluna”nova_string” usando oseparator “_”. Como temos exatamente o mesmo número de sperador em todas as strings, a funções irá nos retornar um vetor de caracteres de tamanho 4.

frutas |> 
  mutate (str_split = str_split(nova_string, "_")) |> 
  pull(str_split)

[[1]]
[1] "a" "1" "1" "a"

[[2]]
[1] "b" "2" "2" "b"

[[3]]
[1] "c" "3" "3" "c"

[[4]]
[1] "d" "4" "4" "d"

[[5]]
[1] "e" "5" "5" "e"

[[6]]
[1] "f" "6" "6" "f"

[[7]]
[1] "g" "7" "7" "g"

[[8]]
[1] "h" "8" "8" "h"

[[9]]
[1] "i" "9" "9" "i"

[[10]]
[1] "j"  "10" "10" "j" 

[[11]]
[1] "k"  "11" "11" "k" 

[[12]]
[1] "l"  "12" "12" "l" 

[[13]]
[1] "m"  "13" "13" "m" 

[[14]]
[1] "n"  "14" "14" "n" 

[[15]]
[1] "o"  "15" "15" "o" 

[[16]]
[1] "p"  "16" "16" "p" 

[[17]]
[1] "q"  "17" "17" "q" 

[[18]]
[1] "r"  "18" "18" "r" 

[[19]]
[1] "s"  "19" "19" "s" 

[[20]]
[1] "t"  "20" "20" "t" 

[[21]]
[1] "u"  "21" "21" "u" 

[[22]]
[1] "v"  "22" "22" "v" 

[[23]]
[1] "w"  "23" "23" "w" 

[[24]]
[1] "x"  "24" "24" "x" 

[[25]]
[1] "y"  "25" "25" "y" 

[[26]]
[1] "z"  "26" "26" "z" 

[[27]]
[1] "A"  "27" "27" "A" 

[[28]]
[1] "B"  "28" "28" "B" 

[[29]]
[1] "C"  "29" "29" "C" 

[[30]]
[1] "D"  "30" "30" "D" 

Se quisermos “quebrar” uma string usando um separador e já gerarmos as respectivas colunas em uma tabela, podemos usar a função str_split_fixed(), extrairmos as respectivas matrizes e adicionarmos como colunas na tabela, podemos fazer: .

4.6.0.5 str_glue

Use para interpolar/formatar uma string.

Por exemplo, se tivermos duas strings: s1 = “Fulano” e s2 = “da Silva”. Podemos “colar” estas strings usando a função str_glue().

s1 <- "Fulano"
s2 <- "da Silva"
str_glue("{s1}"," ", "{s2}")

Fulano da Silva

Podemos também juntar strings fixas e variáveis como no exemplo abaixo.

s1 <- "Fulano"
s2 <- "da Silva"
str_glue("Meu nome é {s1}"," ", "{s2}")

Meu nome é Fulano da Silva

4.6.0.6 str_glue_data

É similar a função str_glue, mas adequada a objetos de dados.

Por exemplo, vamos juntar o nome das frutas, o nome da linha da tabela que ela está e mais uma string fixa:

fruit |> str_glue_data("A {name} é uma fruta.") 

A Apple é uma fruta.
A Apricot é uma fruta.
A Avocado é uma fruta.
A Banana é uma fruta.
A Blackberry é uma fruta.
A Blueberry é uma fruta.
A Cherry é uma fruta.
A Coconut é uma fruta.
A Custard-Apple é uma fruta.
A Dragonfruit é uma fruta.
A Fig é uma fruta.
A Gooseberry é uma fruta.
A Grapes é uma fruta.
A Guava é uma fruta.
A Jackfruit é uma fruta.
A Java Plum é uma fruta.
A Kiwifruit é uma fruta.
A Lime é uma fruta.
A Mango é uma fruta.
A MuskMelon é uma fruta.
A Olives é uma fruta.
A Orange é uma fruta.
A Papaya é uma fruta.
A Peach é uma fruta.
A Pear é uma fruta.
A Pineapple é uma fruta.
A Pomegranate é uma fruta.
A Strawberry é uma fruta.
A Tamarind é uma fruta.
A Watermelon é uma fruta.

4.7 Ordenando String

4.7.0.1 str_order

Use para sequenciar um vetor de caracteres.

Por exemplo, para colocar em sequência de forma decrescente os nomes da frutas, podemos usar:

  str_order(fruit$name, decreasing = TRUE)

 [1] 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6
[26]  5  4  3  2  1

O resultado será uma sequência (descrescente) em que cada item do vetor está.

4.7.0.2 str_sort

Use para ordenar um vetor de caracteres.

Por exemplo, para ordenar de forma decrescente os nomes da frutas, podemos usar:

str_sort(fruit$name, decreasing = TRUE) |> 
  as_tibble(.name_repair = "unique") 

4.8 Auxiliares

4.8.0.1 str_conv

Use para converter o “encode” de uma string.

x <- rawToChar(as.raw(177))
x

[1] "\xb1"

str_conv(x, "ISO-8859-2") # Polones a com cedilha"

[1] "ą"

str_conv(x, "ISO-8859-1") # Mais-Menos

[1] "±"

4.8.0.2 str_view_all

Use para ver os valores encontrados na string de acordo com um padrão de busca.

Por exemplo, se tivermos o padrão de busca como “er”, podemos ver onde na strings ele é encontrado.

str_view(c("Banana", "Blueberry", "Blackberry"), "er") 

Nota

A função str_view_all(), mostrará todos os encontros na string, se quiser para a busca do padrão no primeiro encontro, usa str_view().

4.8.0.3 str_wrap

Use para formatar uma string em parágrafos.

thanks_path <- file.path(R.home("doc"), "THANKS")
thanks <- str_c(readLines(thanks_path), collapse = "\n")
thanks <- word(thanks, 1, 3, fixed("\n\n"))
cat(str_wrap(thanks, width = 60, indent = 2), "\n")

  R would not be what it is today without the invaluable
help of these people outside of the (former and current)
R Core team, who contributed by donating code, bug fixes
and documentation: Valerio Aimale, Suharto Anggono, Thomas
Baier, Gabe Becker, Henrik Bengtsson, Roger Bivand, Ben
Bolker, David Brahm, G"oran Brostr"om, Patrick Burns,
Vince Carey, Saikat DebRoy, Matt Dowle, Brian D'Urso,
Lyndon Drake, Dirk Eddelbuettel, Claus Ekstrom, Sebastian
Fischmeister, John Fox, Paul Gilbert, Yu Gong, Gabor
Grothendieck, Frank E Harrell Jr, Peter M. Haverty,
Torsten Hothorn, Robert King, Kjetil Kjernsmo, Roger
Koenker, Philippe Lambert, Jan de Leeuw, Jim Lindsey,
Patrick Lindsey, Catherine Loader, Gordon Maclean, Arni
Magnusson, John Maindonald, David Meyer, Ei-ji Nakama,
Jens Oehlschl"agel, Steve Oncley, Richard O'Keefe, Hubert
Palme, Roger D. Peng, Jose' C. Pinheiro, Tony Plate, Anthony
Rossini, Jonathan Rougier, Petr Savicky, Guenther Sawitzki,
Marc Schwartz, Arun Srinivasan, Detlef Steuer, Bill Simpson,
Gordon Smyth, Adrian Trapletti, Terry Therneau, Rolf Turner,
Bill Venables, Gregory R. Warnes, Andreas Weingessel, Morten
Welinder, James Wettenhall, Simon Wood, and Achim Zeileis.
Others have written code that has been adopted by R and is
acknowledged in the code files, including 

4.9 Expressões Regulares

Padrões de buscas são interpretados na funções do pacote stringr como Expressões Regulares (regex). Ou seja, quando uma função possui o parametro pattern =, significa que o interpretador irá entendem como uma expressão regular por padrão. Você pode alterar o interpretadores para outros tipos se necessário. Para saber mais sobre isso, acesse Outras Interpretações.

Expressão Regular é uma sequência de caracteres que especificam um padrão de busca em uma string.

Lembre-se que no R, você escreve uma expressão regular como um string, ou seja, uma sequência de caracteres entre aspas simples ’ ou duplas “.

Alguns caracteres de uma expressão regular não podem ser representados diretamente como uma string no R.

Estes são conhecidos como caracteres especiais e são uma sequência de caracteres que tem um significado específico.

Por exemplo:

Caracteres Especiais	Representa
\\	\
\”	”
\?	?

Dica

Para obter a lista completa, digite ? “’”.

Devido a isto, sempre que aparecer uma barra invertida ( \ ) em uma expressão regular, você deve digitar duas barras ( \\ ) na strings da expressão.

Isto é uma particularidade do R e outras linguagens isto pode não ser necessário.

Use a função writeLines() para ver como o R vê sua string depois dos caracteres especiais forem lido.

writeLines("\\.")

\.

writeLines("\\")

\

Como exemplo inicial, vamos utilizar a função str_extract() que recebe um string como parametro e também aceita o padrão de busca como outro parametro.

Iremos definir nosso padrão de busca como a letra “a”. Desta forma, se passarmos para a função str_extract() a string “Banana” e o padrão “a”, ele deve retornar a letra “a”, pois a string Banana possui a letra “a”.

str_extract ("Banana", "a")

[1] "a"

Por outro lado, se passarmos a string “Fig” com o mesmo padrão de busca, teremos NA como retorno, pois a string “Fig” não possui a letra “a”.

str_extract ("Fig", "a")

[1] NA

4.9.1 Combinando Caracteres

No exemplo anterior utilizamos apenas um caractere como padrão de busca, no caso a letra “a”.

Quando desejamos combinar diversos caracteres (letras, numeros, simbolos, espaços, etc) utilizamos a expressões na tabela abaixo:

Para facilitar o entendimento, utilizaremos uma string com letras maiúsculas, minúsculas, símbolos e números:

Str_Teste <- "abc ABC 123\t.!?\\(){}\n"
Str_Teste

[1] "abc ABC 123\t.!?\\(){}\n"

String Regex no R	Busca por
a	a (etc.)
\\.	.
\\!	\!
\\?	\?
\\\\	\\
\\(	\(
\\)	\)
\\{	\{
\\}	\}
\\n	nova linha (ENTER)
\\t	TAB
\\s	qualquer caractere em branco
\\d	qualquer digito
\\w	qualquer letra
\\b	barra de espaço
[:digit:]	digitos
[:alpha:]	letras
[:lower:]	letras minúsculas
[:upper:]	letras maiúsculas
[:alnum:]	letras e números
[:punct:]	pontuação
[:graph:]	letras, números e pontuação
[:space:]	qualquer espaço em branco
[:blank:]	espaço em branco e barra de espaço (mas não nova linha)
.	qualquer caractere exceto nova linha (ENTER)

Vamos mostrar como usar a tabela acima com alguns exemplos. Para isso, iremos usar a string criada anteriormente chamada “Str_Teste”.

Exemplo 1:

Vamos buscar em nossa string de teste (Str_Teste) a letra minúscula “a”.

Na coluna da tabela acima chamada String, encontramos oque devemos digitar para construir o padrão de busca. Neste caso, seria “a”.

Se usarmos a função str_view_all() passando nossa “Str_Teste” e o padrão de busca “a”, observamos que teremos marcado apenas a letra “a” na string. Isto significa que o padrão de busca foi encontrado na string.

str_view_all (Str_Teste, "a")

Nota

As funções str_view() e str_view_all() mostram em HTML o encontro de uma expressão regular. São muito úteis para criar/validar sua expressão. A str_view, mostra o primeiro encontro e para a busca, a str_view_all, mostra todos os encontros.

Exemplo 2:

Vamos buscar agora pelo padrão do símbolo de ponto de interrogação “?”. Similar ao exemplo anterior, vemos que apenas o ponto de interrogação foi encontrado.

str_view_all (Str_Teste, "\\?")

Exemplo 3:

Vamos criar agora um padrão que busque por todos os digitos em nossa string.

str_view_all (Str_Teste, "\\d")

Dica

Para buscarmos pelo inverso do caso anterior, ou seja, todos os caracteres que NÃO são digitos, usamos a letra “D” maiúscula. Isto é válido também para os casos de “\\S” e “\\W” que seriam o inverso de “\\s” e “\\w” respectivamente.

str_view_all (Str_Teste, "\\D")

Exemplo 4:

Vamos criar agora um padrão que busque por todos os digitos e letras em nossa string.

str_view_all (Str_Teste, "[:alnum:]")

4.9.2 Quantificadores

Agora que já sabemos como criar padrões de busca para identificar diversos tipos de caracteres, veremos como definir a quantidade desses caracteres em nosso padrão. Veja a tabela abaixo:

Regex	Busca
?	Zero ou um
*	Zero ou mais
+	Um ou mais
{n}	Exatamente n
{n,}	n ou mais
{n,m}	Entre n e m

Vamos ver como utilizamos estes quantificadores juntamente com os caracteres especiais vistos anteriormente (ver Combinando Caracteres).

Para os exemplos a seguir utilizaremos a seguinte string de teste: Str_Teste_2 = “.a.aa.aaa”

Str_Teste_2 <- ".a.aa.aaa"

Exemplo 1:

Digamos que queremos buscar em nossa string de teste “Str_Teste_2” a letra “a” zero ou uma vez, para isso faremos:

str_view_all(Str_Teste_2, "a?")

Neste caso, todas as vezes que a funções encontrar a letra “a” zero ou uma vez, elá irá marcar.

Aviso

Como visto, se usarmos a função str_view() ela irá utilizar o padrão apenas até o primeiro encontro e depois irá para a busca, veja:

str_view(Str_Teste_2, "a?")

Observe que a busca para logo no primeiro caractere, pois estamos buscando pela letra “a” ZERO ou mais vezes.

Exemplo 2:

Agora vamos iremos buscar pela letra “a” UMA ou mais vezes, porém iremos utilizar a função str_view() ou invés da str_view_all(), parando a busca assim que o primeiro encontro ocorra:

str_view(Str_Teste_2, "a+")

Exemplo 3:

Neste exemplo, queremos criar um padrão de busca pela letra “a”, mas que ela ocorra DUAS a TRÊS vezes.

str_view(Str_Teste_2, "a{2,3}")

Veja que ele localizou apenas as duas letras “aa” e não marcou as letras “aaa”. Isto é porque utilizamos a função str_view(), que parou a busca assim que a primeiro encontro ocorreu. Se quisermos continuar a busca, devemos utilizar a função str_view_all().

str_view_all(Str_Teste_2, "a{2,3}")

Exemplo 4:

Neste exemplo, usaremos a tabela frutas, criada quando descrevemos a função str_c. Veja como ela é para se recordar:

frutas |> 
  head() 

Digamos que precisamos extrair apenas os números da coluna “nova_string”. E colocá-los em uma nova coluna chamda “numeros”.

Neste caso, podemos usar a função str_extract() com um padrão que encontre um número de 0 até 9, seguido por um ou mais “qualquer caractere” e depois outro número de 0 até 9.

Este padrão irá encontrar padrões como “1_1” ou “2_2”.

Em seguida, usamos um outro padrão [:punct:] na função str_remove para remover a pontuação.

frutas |> 
  mutate (numeros = str_extract(nova_string, "[0-9].+[0-9]")) |> 
  mutate (numeros = str_remove(numeros, "[:punct:]"))

4.9.3 Alternadores

Até aqui, utilizamos os caracteres especiais (Combinando Caracteres) e sabemos como localizá-los em diversas quantidades (Quantificadores). Mas em muitos casos precisamos organizá-los de forma lógica, possibilitando utilizá-los em combinações mais flexíveis.

Para isto, utilizamos os símbolos de alternadores, veja:

Para os exemplos a seguir utilizaremos a seguinte string de teste: Str_Teste_3 = “abcde”

Regex	Busca
|	OU
[ ]	Um dos
[^ ]	Tudo exceto
[ - ]	Range

Str_Teste_3 <- "abcde"

Exemplo 1:

Digamos que desejamos criar um padrão que busque pela letras “ab” OU a letra “d”, para isto podemos usar:

str_view_all(Str_Teste_3, "ab|d")

Exemplo 2:

Digamos que desejamos criar um padrão que busque qualquer um dos caracteres “abe”, para isto podemos usar:

str_view_all(Str_Teste_3, "[abe]")

Exemplo 3:

Digamos que desejamos criar um padrão que busque dentre um range de letras entre as letras “a” até a “c”, para isto podemos usar:

str_view_all(Str_Teste_3, "[a-c]")

Exemplo 4:

Neste exemplo, usaremos novamente a tabela frutas, criada quando descrevemos a função str_c.

Digamos que precisamos filtrar nesta tabela, apenas as frutas que possuem nomes compostos, ou seja, separados por espaço ou uma pontuação (ex “-”).

Podemos usar a função filter() passando o resultado da função str_detect() junto com um padrão.

Há diversas maneiras de construir este padrão. Aqui optar por buscar por caracteres alfa-numéricos (letras e números) e usamos o alternador [^ ] para negar tais caracteres, portanto, iremos identificar se a string NÃO possui letras ou números.

frutas |> 
  filter (str_detect(name, "[^[:alnum:]]")) 

4.9.4 Ancoragem

Para definir se a sequência do padrão de busca está no início ou fim da string, utilizamos as expressões de ancoragem:

Regex	Busca
^	Início da string
$	Fim da string

Para os exemplos a seguir utilizaremos a seguinte string de teste: Str_Teste_4 = “aaa”

Str_Teste_4 <- "aaa"

Exemplo 1:

Para criar um padrão que busque a letra “a” apenas no fim da string, usamos:

str_view_all(Str_Teste_4, "a$")

Exemplo 2:

Para criar um padrão que busque a letra “a” apenas no início da string, usamos:

str_view_all(Str_Teste_4, "^a")

Exemplo 3:

Neste exemplo, usaremos novamente a tabela frutas, criada quando descrevemos a função str_c.

Digamos que queremos filtrar apenas as frutas que terminem com a letra “a” E também que terminem com a letra “o”. Podemos fazer:

frutas |> 
  filter (str_detect(name, "[ao]$")) 

4.9.5 Grupos

Você pode utilizar parênteses ( ) para definir expressões de precedência ou para serem referenciados posteriormente através da ordem de criação.

Para os exemplos a seguir utilizaremos a seguinte string de teste: Str_Teste_5 = “abbaab”

Str_Teste_5 <- "abbaab"

Exemplo 1:

Digamos que tenhamos a string “Blueberry” e você queira criar um padrão que contenha as letras “lu” OU “b” seguidas pela letra “e”.

Neste caso, devemos criar um grupo de precedência para “lu” OU “b”. Para isto iremos colocar esta parte da expressão entre parênteses (lu|b). agora podemos utilizar este grupo e concluir o padrão de busca conforme a seguir:

str_view_all("Blueberry", "(lu|b)e")

Veja que se nossa string fosse “Blueberry is special”, a letra “e” de “special” não seria encontrada:

str_view_all("Blueberry is special", "(lu|b)e")

Se quisermos criar um padrão que encontre a letra “e” precedida de qualquer letra, podemos fazer:

str_view_all("Blueberry is special", "([:alpha:])e")

Exemplo 2:

Ao criar um grupo, como vimos no exemplo anterior, podemos fazer referência à este grupo usando \\n, on n é a ordem de criação do grupo.

Por exemplo, digamos que criamos um grupo utilizando os parênteses ( ) que contenha apenas letra “a”. Seu código ficaria (a), e ele poderia ser referenciado com \\1, pois foi o primeiro grupo a ser criado.

Digamos que agora, você crie um segundo grupo com a letra “b”, seu código ficaria (b) e poderia ser referenciado com \\2.

Sabendo como criar os grupos e como referênciá-los, podemos montar um padrão de busca utilizando tanto os grupos quanto suas referência. Veja este exemplo:

str_view_all(Str_Teste_5, "(a)(b)\\2\\1")

Neste exemplo, nosso padrão busca por “ba”, atraveś de \\2\\1, desde que tenham precedência de “ab”, através dos grupos (a)(b).

Exemplo 3:

Digamos que tenhamos a string “Tem uma banana na mesa”. Queremos criar uma padrão que busque as letras “nana”. Apesar de termos soluções mais simples, poderíamos criar um grupo contendo “na” e usar a ordem de referência para concluir a expressão:

str_view_all("Tem uma banana na mesa", "(na)\\1")

Exemplo 4:

Neste exemplo, usaremos novamente a tabela frutas, criada quando descrevemos a função str_c.

Aqui iremos obter o mesmo resultado para o Exemplo 4 descrito na seção Quantificadores.

Porém agora vamos usar a função str_replace() e o suporte a grupos que acabamos de ver para atingir o mesmo resultado, ou seja, extrair apenas os números da coluna nova_string.

frutas |> 
  mutate (numeros = str_replace(nova_string, ".+([0-9]).?([0-9]).+", "\\1\\2")) 

Detalhes do exemplo acima:

Observe que a função str_replace(), recebe dois argumentos separados por vígula, sendo o primeiro, o padrão de busca e o segundo, o padrão daquilo que iremos substituir o primeiro.

Neste caso, nosso padrão de busca, encontra “qualquer caractere” “uma ou mais vezes”, depois cria um “grupo com números de 0 a 9”, seguido por “qualquer caractere zero ou uma vez”.

Depois cria o segundo “grupo com números de 0 à 9” e conclui com “qualquer caractere uma ou mais vezes”.

Veja que este padrão de busca, na verdade encontra todos os caracteres de nossa string, mas guarda em dois grupos apenas os números.

Com nosso padrão de busca criado, iremos criar nosso padrão de substituição, ou seja, aquilo que for encontrado pelo padrão de busca, será substituído pelo padrão de substituição.

Nosso padrão de substituição ficou simples (“\\1\\2”). Veja que ele apenas pega o conteúdo do grupo 1 e grupo 2 criados no padrão de busca usando parênteses para substituir.

4.9.6 Pesquisa ao Redor

Em alguns casos, precisamos criar um padrão que olhe ao redor para encontrar o que buscamos.

Há símbolos para definirmos grupos que estão precedendo o que buscamos e há símbolos para definirmos grupos que estão posteriores ao que buscamos. Há também símbolos para negar os casos anteriores e posteriores.

Veja a tabela:

Para os exemplos a seguir utilizaremos a seguinte string de teste: Str_Teste_6 = “bacad”

Regex	Busca
(?= )	Seguido por
(?! )	Não seguido por
(?<= )	Precedido por
(?<! )	Não precedido por

Str_Teste_6 <- "bacad"

Exemplo 1:

Vamos criar um padrão de busca que localize a letra “a”, mas queremos a(s) letra(s) “a” que são seguidas apenas pela letra “c”.

Para isso iremos criar um grupo (“c”), mas como é um grupo que irá seguir aquilo que buscamos, ao invés dos parêntese apenas, iremos utilizar o símbolo da tabela anterior “?=”a fazer (?=c). Depois adicionamos a busca pela letra “a”.

str_view_all(Str_Teste_6, "a(?=c)")

Exemplo 2:

Vamos criar um padrão de busca que localize a letra “a”, mas queremos a(s) letra(s) “a” que são precedidas pela letra “b”. Usando a mesma tabela e raciocínio do exemplo anterior, podemos criar o grupo com a letra b, mas como é um grupo de precedência, temos que adicionar os símbolos “?<=” e fazer:

str_view_all(Str_Teste_6, "(?<=b)a")

Exemplo 4:

Neste exemplo, usaremos novamente a tabela frutas, criada quando descrevemos a função str_c.

Digamos que iremos filtrar as frutas que comecem com as letras “B” e “P” se forem seguidas das letras “e” e “l”. Desta forma, não teremos na saída frutas como “Banana” ou “Pineapple”

frutas |> 
  filter(str_detect(name, "^[BP](?=[el])")) 

4.10 Outras Interpretações

4.10.0.1 regex

Conforme visto na seção Expressões Regulares, o interpretador padrão das funções do pacote stringr, é o regex, ou seja, sempre que tivermos o parâmetro pattern =, se não especificarmos nada, ele irá interpretar a string deste parêmetro como se fosse uma expressão regular (regex).

A seguir, veremos como mudar este padrão e introduzir outros interpretadores disponíveis.

4.10.0.2 fixed

Para buscar bytes nativos (raw), podemos usar o interpretador fixed(). Esta opção é bastante rápida, mas pode perder alguns caracteres que podem estar representados de maneiras diferentes (ex não ASCII).

Exemplo:

str_detect("\u0130", fixed("i"))

[1] FALSE

4.10.0.3 coll

Para comparar strings respeitando seu agrupamento. Interessante para strings com localização e não sensíveis a maiúsculas ou minúsculas.

Exemplo:

str_detect("\u0130", coll("i", TRUE, locale = "tr"))

[1] TRUE

4.10.0.4 boundary

Para localizar fronterias entre caracteres. quebra de linhas, sentenças ou palavras.

Dica

Para maiores informações veja os exemplo digitando ?stringr::modifiers